// 哈希生成工具
class HashGenerator {
    /**
     * 生成文本哈希值
     * @param {string} input - 输入文本
     * @param {string} algorithm - 哈希算法 ('md5', 'sha1', 'sha256', 'sha512')
     * @returns {Object} - 处理结果
     */
    static async generateTextHash(input, algorithm = 'md5') {
        try {
            if (!input && input !== '') {
                return { success: false, error: '请输入要生成哈希值的文本' };
            }

            const supportedAlgorithms = ['md5', 'sha1', 'sha256', 'sha512'];
            if (!supportedAlgorithms.includes(algorithm)) {
                return { success: false, error: '不支持的哈希算法' };
            }

            let hashValue;
            const encoder = new TextEncoder();
            const data = encoder.encode(input);

            if (algorithm === 'md5') {
                hashValue = await this.generateMD5(input);
            } else {
                const algorithmName = algorithm.toUpperCase().replace(/(\d+)/, '-$1');
                const hashBuffer = await crypto.subtle.digest(algorithmName, data);
                hashValue = this.bufferToHex(hashBuffer);
            }

            return {
                success: true,
                data: {
                    input: input,
                    algorithm: algorithm.toUpperCase(),
                    hash: hashValue,
                    inputLength: input.length,
                    hashLength: hashValue.length,
                    timestamp: new Date().toISOString()
                }
            };
        } catch (error) {
            return { success: false, error: '哈希生成失败: ' + error.message };
        }
    }

    /**
     * 生成文件哈希值
     * @param {File} file - 文件对象
     * @param {string} algorithm - 哈希算法
     * @returns {Object} - 处理结果
     */
    static async generateFileHash(file, algorithm = 'md5') {
        try {
            if (!file) {
                return { success: false, error: '请选择文件' };
            }

            const maxSize = 100 * 1024 * 1024; // 100MB
            if (file.size > maxSize) {
                return { success: false, error: '文件大小不能超过100MB' };
            }

            const supportedAlgorithms = ['md5', 'sha1', 'sha256', 'sha512'];
            if (!supportedAlgorithms.includes(algorithm)) {
                return { success: false, error: '不支持的哈希算法' };
            }

            const arrayBuffer = await file.arrayBuffer();
            let hashValue;

            if (algorithm === 'md5') {
                // 将 ArrayBuffer 转换为字符串来计算 MD5
                const uint8Array = new Uint8Array(arrayBuffer);
                const binaryString = Array.from(uint8Array, byte => String.fromCharCode(byte)).join('');
                hashValue = await this.generateMD5(binaryString);
            } else {
                const algorithmName = algorithm.toUpperCase().replace(/(\d+)/, '-$1');
                const hashBuffer = await crypto.subtle.digest(algorithmName, arrayBuffer);
                hashValue = this.bufferToHex(hashBuffer);
            }

            return {
                success: true,
                data: {
                    fileName: file.name,
                    fileSize: file.size,
                    fileType: file.type || 'unknown',
                    algorithm: algorithm.toUpperCase(),
                    hash: hashValue,
                    hashLength: hashValue.length,
                    timestamp: new Date().toISOString(),
                    formattedSize: this.formatFileSize(file.size)
                }
            };
        } catch (error) {
            return { success: false, error: '文件哈希生成失败: ' + error.message };
        }
    }

    /**
     * 批量生成哈希值
     * @param {string} input - 输入内容（每行一个）
     * @param {string} algorithm - 哈希算法
     * @returns {Object} - 处理结果
     */
    static async batchGenerateHash(input, algorithm = 'md5') {
        try {
            if (!input || !input.trim()) {
                return { success: false, error: '请输入要处理的内容' };
            }

            const lines = input.split('\n').map(line => line.trim()).filter(line => line);
            
            if (lines.length === 0) {
                return { success: false, error: '没有有效的内容' };
            }

            if (lines.length > 1000) {
                return { success: false, error: '批量处理最多支持1000行' };
            }

            const results = [];
            let successCount = 0;
            let errorCount = 0;

            for (let i = 0; i < lines.length; i++) {
                const line = lines[i];
                const result = await this.generateTextHash(line, algorithm);
                
                results.push({
                    line: i + 1,
                    input: line,
                    success: result.success,
                    hash: result.success ? result.data.hash : null,
                    error: result.success ? null : result.error
                });

                if (result.success) {
                    successCount++;
                } else {
                    errorCount++;
                }
            }

            return {
                success: true,
                data: {
                    algorithm: algorithm.toUpperCase(),
                    results: results,
                    summary: {
                        total: lines.length,
                        success: successCount,
                        error: errorCount
                    }
                }
            };
        } catch (error) {
            return { success: false, error: '批量处理失败: ' + error.message };
        }
    }

    /**
     * 验证哈希值
     * @param {string} input - 输入内容
     * @param {string} expectedHash - 期望的哈希值
     * @param {string} algorithm - 哈希算法
     * @returns {Object} - 验证结果
     */
    static async verifyHash(input, expectedHash, algorithm = 'md5') {
        try {
            if (!input && input !== '') {
                return { success: false, error: '请输入要验证的内容' };
            }

            if (!expectedHash || !expectedHash.trim()) {
                return { success: false, error: '请输入期望的哈希值' };
            }

            const cleanExpectedHash = expectedHash.trim().toLowerCase();
            const generateResult = await this.generateTextHash(input, algorithm);

            if (!generateResult.success) {
                return generateResult;
            }

            const actualHash = generateResult.data.hash.toLowerCase();
            const isMatch = actualHash === cleanExpectedHash;

            return {
                success: true,
                data: {
                    input: input,
                    algorithm: algorithm.toUpperCase(),
                    expectedHash: cleanExpectedHash,
                    actualHash: actualHash,
                    isMatch: isMatch,
                    result: isMatch ? 'PASS' : 'FAIL',
                    message: isMatch ? '哈希值验证通过' : '哈希值验证失败'
                }
            };
        } catch (error) {
            return { success: false, error: '哈希验证失败: ' + error.message };
        }
    }

    /**
     * 比较两个文件的哈希值
     * @param {File} file1 - 第一个文件
     * @param {File} file2 - 第二个文件
     * @param {string} algorithm - 哈希算法
     * @returns {Object} - 比较结果
     */
    static async compareFiles(file1, file2, algorithm = 'md5') {
        try {
            if (!file1 || !file2) {
                return { success: false, error: '请选择两个文件进行比较' };
            }

            const hash1Result = await this.generateFileHash(file1, algorithm);
            const hash2Result = await this.generateFileHash(file2, algorithm);

            if (!hash1Result.success) {
                return { success: false, error: '第一个文件处理失败: ' + hash1Result.error };
            }

            if (!hash2Result.success) {
                return { success: false, error: '第二个文件处理失败: ' + hash2Result.error };
            }

            const isIdentical = hash1Result.data.hash === hash2Result.data.hash;

            return {
                success: true,
                data: {
                    file1: hash1Result.data,
                    file2: hash2Result.data,
                    algorithm: algorithm.toUpperCase(),
                    isIdentical: isIdentical,
                    result: isIdentical ? 'IDENTICAL' : 'DIFFERENT',
                    message: isIdentical ? '文件内容相同' : '文件内容不同'
                }
            };
        } catch (error) {
            return { success: false, error: '文件比较失败: ' + error.message };
        }
    }

    /**
     * 生成 MD5 哈希值（使用第三方库的简化版本）
     * @param {string} input - 输入字符串
     * @returns {string} - MD5 哈希值
     */
    static async generateMD5(input) {
        // 简化的 MD5 实现，用于演示
        // 在实际项目中建议使用专业的加密库如 crypto-js
        const md5 = this.simpleMD5(input);
        return md5;
    }

    /**
     * 简化的 MD5 实现
     * @param {string} string - 输入字符串
     * @returns {string} - MD5 哈希值
     */
    static simpleMD5(string) {
        function md5cycle(x, k) {
            var a = x[0], b = x[1], c = x[2], d = x[3];
            a = ff(a, b, c, d, k[0], 7, -680876936);
            d = ff(d, a, b, c, k[1], 12, -389564586);
            c = ff(c, d, a, b, k[2], 17, 606105819);
            b = ff(b, c, d, a, k[3], 22, -1044525330);
            a = ff(a, b, c, d, k[4], 7, -176418897);
            d = ff(d, a, b, c, k[5], 12, 1200080426);
            c = ff(c, d, a, b, k[6], 17, -1473231341);
            b = ff(b, c, d, a, k[7], 22, -45705983);
            a = ff(a, b, c, d, k[8], 7, 1770035416);
            d = ff(d, a, b, c, k[9], 12, -1958414417);
            c = ff(c, d, a, b, k[10], 17, -42063);
            b = ff(b, c, d, a, k[11], 22, -1990404162);
            a = ff(a, b, c, d, k[12], 7, 1804603682);
            d = ff(d, a, b, c, k[13], 12, -40341101);
            c = ff(c, d, a, b, k[14], 17, -1502002290);
            b = ff(b, c, d, a, k[15], 22, 1236535329);
            a = gg(a, b, c, d, k[1], 5, -165796510);
            d = gg(d, a, b, c, k[6], 9, -1069501632);
            c = gg(c, d, a, b, k[11], 14, 643717713);
            b = gg(b, c, d, a, k[0], 20, -373897302);
            a = gg(a, b, c, d, k[5], 5, -701558691);
            d = gg(d, a, b, c, k[10], 9, 38016083);
            c = gg(c, d, a, b, k[15], 14, -660478335);
            b = gg(b, c, d, a, k[4], 20, -405537848);
            a = gg(a, b, c, d, k[9], 5, 568446438);
            d = gg(d, a, b, c, k[14], 9, -1019803690);
            c = gg(c, d, a, b, k[3], 14, -187363961);
            b = gg(b, c, d, a, k[8], 20, 1163531501);
            a = gg(a, b, c, d, k[13], 5, -1444681467);
            d = gg(d, a, b, c, k[2], 9, -51403784);
            c = gg(c, d, a, b, k[7], 14, 1735328473);
            b = gg(b, c, d, a, k[12], 20, -1926607734);
            a = hh(a, b, c, d, k[5], 4, -378558);
            d = hh(d, a, b, c, k[8], 11, -2022574463);
            c = hh(c, d, a, b, k[11], 16, 1839030562);
            b = hh(b, c, d, a, k[14], 23, -35309556);
            a = hh(a, b, c, d, k[1], 4, -1530992060);
            d = hh(d, a, b, c, k[4], 11, 1272893353);
            c = hh(c, d, a, b, k[7], 16, -155497632);
            b = hh(b, c, d, a, k[10], 23, -1094730640);
            a = hh(a, b, c, d, k[13], 4, 681279174);
            d = hh(d, a, b, c, k[0], 11, -358537222);
            c = hh(c, d, a, b, k[3], 16, -722521979);
            b = hh(b, c, d, a, k[6], 23, 76029189);
            a = hh(a, b, c, d, k[9], 4, -640364487);
            d = hh(d, a, b, c, k[12], 11, -421815835);
            c = hh(c, d, a, b, k[15], 16, 530742520);
            b = hh(b, c, d, a, k[2], 23, -995338651);
            a = ii(a, b, c, d, k[0], 6, -198630844);
            d = ii(d, a, b, c, k[7], 10, 1126891415);
            c = ii(c, d, a, b, k[14], 15, -1416354905);
            b = ii(b, c, d, a, k[5], 21, -57434055);
            a = ii(a, b, c, d, k[12], 6, 1700485571);
            d = ii(d, a, b, c, k[3], 10, -1894986606);
            c = ii(c, d, a, b, k[10], 15, -1051523);
            b = ii(b, c, d, a, k[1], 21, -2054922799);
            a = ii(a, b, c, d, k[8], 6, 1873313359);
            d = ii(d, a, b, c, k[15], 10, -30611744);
            c = ii(c, d, a, b, k[6], 15, -1560198380);
            b = ii(b, c, d, a, k[13], 21, 1309151649);
            a = ii(a, b, c, d, k[4], 6, -145523070);
            d = ii(d, a, b, c, k[11], 10, -1120210379);
            c = ii(c, d, a, b, k[2], 15, 718787259);
            b = ii(b, c, d, a, k[9], 21, -343485551);
            x[0] = add32(a, x[0]);
            x[1] = add32(b, x[1]);
            x[2] = add32(c, x[2]);
            x[3] = add32(d, x[3]);
        }

        function cmn(q, a, b, x, s, t) {
            a = add32(add32(a, q), add32(x, t));
            return add32((a << s) | (a >>> (32 - s)), b);
        }

        function ff(a, b, c, d, x, s, t) {
            return cmn((b & c) | ((~b) & d), a, b, x, s, t);
        }

        function gg(a, b, c, d, x, s, t) {
            return cmn((b & d) | (c & (~d)), a, b, x, s, t);
        }

        function hh(a, b, c, d, x, s, t) {
            return cmn(b ^ c ^ d, a, b, x, s, t);
        }

        function ii(a, b, c, d, x, s, t) {
            return cmn(c ^ (b | (~d)), a, b, x, s, t);
        }

        function md51(s) {
            var n = s.length,
                state = [1732584193, -271733879, -1732584194, 271733878],
                i;
            for (i = 64; i <= s.length; i += 64) {
                md5cycle(state, md5blk(s.substring(i - 64, i)));
            }
            s = s.substring(i - 64);
            var tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
            for (i = 0; i < s.length; i++)
                tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
            tail[i >> 2] |= 0x80 << ((i % 4) << 3);
            if (i > 55) {
                md5cycle(state, tail);
                for (i = 0; i < 16; i++) tail[i] = 0;
            }
            tail[14] = n * 8;
            md5cycle(state, tail);
            return state;
        }

        function md5blk(s) {
            var md5blks = [],
                i;
            for (i = 0; i < 64; i += 4) {
                md5blks[i >> 2] = s.charCodeAt(i) +
                    (s.charCodeAt(i + 1) << 8) +
                    (s.charCodeAt(i + 2) << 16) +
                    (s.charCodeAt(i + 3) << 24);
            }
            return md5blks;
        }

        var hex_chr = '0123456789abcdef'.split('');

        function rhex(n) {
            var s = '',
                j = 0;
            for (; j < 4; j++)
                s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] +
                hex_chr[(n >> (j * 8)) & 0x0F];
            return s;
        }

        function hex(x) {
            for (var i = 0; i < x.length; i++)
                x[i] = rhex(x[i]);
            return x.join('');
        }

        function add32(a, b) {
            return (a + b) & 0xFFFFFFFF;
        }

        return hex(md51(string));
    }

    /**
     * 将 ArrayBuffer 转换为十六进制字符串
     * @param {ArrayBuffer} buffer - 缓冲区
     * @returns {string} - 十六进制字符串
     */
    static bufferToHex(buffer) {
        return Array.from(new Uint8Array(buffer))
            .map(b => b.toString(16).padStart(2, '0'))
            .join('');
    }

    /**
     * 格式化文件大小
     * @param {number} bytes - 字节数
     * @returns {string} - 格式化后的大小
     */
    static formatFileSize(bytes) {
        if (bytes === 0) return '0 B';
        const k = 1024;
        const sizes = ['B', 'KB', 'MB', 'GB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
    }

    /**
     * 获取支持的哈希算法
     * @returns {Array} - 算法列表
     */
    static getSupportedAlgorithms() {
        return [
            { value: 'md5', label: 'MD5', description: '128位哈希值，速度快但安全性较低' },
            { value: 'sha1', label: 'SHA-1', description: '160位哈希值，Git使用的算法' },
            { value: 'sha256', label: 'SHA-256', description: '256位哈希值，推荐用于安全应用' },
            { value: 'sha512', label: 'SHA-512', description: '512位哈希值，最高安全性' }
        ];
    }

    /**
     * 获取算法信息
     * @param {string} algorithm - 算法名称
     * @returns {Object} - 算法信息
     */
    static getAlgorithmInfo(algorithm) {
        const algorithms = this.getSupportedAlgorithms();
        return algorithms.find(alg => alg.value === algorithm) || null;
    }
}